home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / GDIPAL.PAK / BRUSHDLG.C < prev    next >
C/C++ Source or Header  |  1997-05-06  |  13KB  |  454 lines
  1. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  2. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  3. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  4. // PARTICULAR PURPOSE.
  5. //
  6. // Copyright (C) 1993 - 1995  Microsoft Corporation.  All Rights Reserved.
  7. //
  8. //  MODULE:   brushdlg.c
  9. //
  10. //  PURPOSE:   Displays the "Brush Style" dialog box
  11. //
  12. //  FUNCTIONS:
  13. //    BrushDlg        - Process messages for "Brush Style" dialog box.
  14. //    MsgBrushInit    - Initialize the Brush dialog with info from lparam.
  15. //    MsgBrushPaint   - Paint the Example Window in the Brush dialog
  16. //    MsgBrushCommand - Process WM_COMMAND messages sent to the Brush dialog.
  17. //    CmdBrushStyle   - Track the currently selected brush style.
  18. //    CmdBrushHatch   - Track the currently selected hatch style.
  19. //    CmdBrushColor   - Put up the ChooseColor dialog to select brush color.
  20. //    CmdBrushDone    - Free the Brush dialog and related data.
  21. //
  22. //  COMMENTS:
  23. //
  24.  
  25. #include <windows.h>            // required for all Windows applications
  26. #include <windowsx.h>
  27. #include "globals.h"            // prototypes specific to this application
  28. #include "brushdlg.h"           // Controls ID's for the Brush dialog
  29. #include "colordlg.h"           // palette color dialog defines/prototypes
  30.  
  31. // global variables specific to this module
  32. RECT rcExample;                 // location of example window in dialog
  33.  
  34. // prototypes specific to this module
  35. LRESULT MsgBrushCommand (HWND, UINT, WPARAM, LPARAM);
  36. LRESULT MsgBrushInit    (HWND, UINT, WPARAM, LPARAM);
  37. LRESULT MsgBrushPaint   (HWND, UINT, WPARAM, LPARAM);
  38. LRESULT CmdBrushStyle   (HWND, WORD, WORD, HWND);
  39. LRESULT CmdBrushHatch   (HWND, WORD, WORD, HWND);
  40. LRESULT CmdBrushColor   (HWND, WORD, WORD, HWND);
  41. LRESULT CmdBrushDone    (HWND, WORD, WORD, HWND);
  42.  
  43. // Brush dialog message table definition.
  44. MSD rgmsdBrush[] =
  45. {
  46.     {WM_COMMAND,    MsgBrushCommand},
  47.     {WM_PAINT,      MsgBrushPaint},
  48.     {WM_INITDIALOG, MsgBrushInit}
  49. };
  50.  
  51. MSDI msdiBrush =
  52. {
  53.     sizeof(rgmsdBrush) / sizeof(MSD),
  54.     rgmsdBrush,
  55.     edwpNone
  56. };
  57.  
  58. // Brush dialog command table definition.
  59. CMD rgcmdBrush[] =
  60. {
  61.     {IDD_SOLIDBRUSH,    CmdBrushStyle}, // Brush Style notifications
  62.     {IDD_NULLBRUSH,     CmdBrushStyle},
  63.     {IDD_HATCHBRUSH,    CmdBrushStyle},
  64.     {IDD_HATCHSTYLE,    CmdBrushHatch}, // Hatch Style notification
  65.     {IDD_BRUSHCOLOR,    CmdBrushColor}, // Color button
  66.     {IDOK,              CmdBrushDone},  // OK and Cancel buttons
  67.     {IDCANCEL,          CmdBrushDone}
  68. };
  69.  
  70. CMDI cmdiBrush =
  71. {
  72.     sizeof(rgcmdBrush) / sizeof(CMD),
  73.     rgcmdBrush,
  74.     edwpNone
  75. };
  76.  
  77.  
  78. //
  79. //  FUNCTION: BrushDlg(HWND, UINT, WPARAM, LPARAM)
  80. //
  81. //  PURPOSE:  Processes messages for "Brush Style" dialog box.
  82. //
  83. //  PARAMETERS:
  84. //    hdlg - window handle of the dialog box
  85. //    wMessage - type of message
  86. //    wparam - message-specific information
  87. //    lparam - message-specific information
  88. //
  89. //  RETURN VALUE:
  90. //    TRUE - message handled
  91. //    FALSE - message not handled
  92. //
  93. //  COMMENTS:
  94. //
  95. //
  96.  
  97. LRESULT CALLBACK BrushDlg(HWND hdlg, UINT uMessage, WPARAM wparam, LPARAM lparam)
  98. {
  99.     return DispMessage(&msdiBrush, hdlg, uMessage, wparam, lparam);
  100. }
  101.  
  102.  
  103. //
  104. //  FUNCTION: MsgBrushCommand(HWND, UINT, WPARAM, LPARAM)
  105. //
  106. //  PURPOSE: Process WM_COMMAND messages sent to the Brush dialog.
  107. //
  108. //  PARAMETERS:
  109. //    hwnd      - The window handing the message.
  110. //    uMessage  - The message number. (unused).
  111. //    wparam    - Message specific data (unused).
  112. //    lparam    - Message specific data (unused).
  113. //
  114. //  RETURN VALUE:
  115. //    Always returns 0 - message handled.
  116. //
  117. //  COMMENTS:
  118. //    Uses this DipsCommand function defined in wndproc.c combined
  119. //    with the cmdiBrush structure defined in this file to handle
  120. //    the command messages for the Brush dialog box.
  121. //
  122.  
  123. #pragma argsused
  124. LRESULT MsgBrushCommand(HWND   hwnd,
  125.                         UINT   uMessage, 
  126.                         WPARAM wparam, 
  127.                         LPARAM lparam)
  128. {
  129.     return DispCommand(&cmdiBrush, hwnd, wparam, lparam);
  130. }
  131.  
  132.  
  133. //
  134. //  FUNCTION: MsgBrushInit(HWND, UINT, WPARAM, LPARAM)
  135. //
  136. //  PURPOSE: To initialize the Brush dialog with info from lparam.
  137. //
  138. //  PARAMETERS:
  139. //    hwnd - The window handing the message.
  140. //    uMessage - The message number. (unused).
  141. //    wparam - Message specific data (unused).
  142. //    lparam - points to LOGBRUSH structure.
  143. //
  144. //  RETURN VALUE:
  145. //    Always returns TRUE
  146. //
  147. //  COMMENTS:
  148. //    Sets the initial state of the controls according to the LOGBRUSH
  149. //    passed in via lparam.
  150. //
  151.  
  152. #pragma argsused
  153. LRESULT MsgBrushInit(HWND hdlg, UINT uMessage, WPARAM wparam, LPARAM lparam)
  154. {
  155.      int i, nIndex, nSel;
  156.     HWND hctlHatch;
  157.     char szTmp[32];
  158.     LPLOGBRUSH lpLB;
  159.  
  160.     // lparam is a pointer to a LOGBRUSH structure
  161.     lpLB = (LPLOGBRUSH)lparam;
  162.  
  163.     // Save pointer to LOGBRUSH structure in window bytes
  164.     SetWindowLong(hdlg, DWL_USER, (LONG)lpLB);
  165.  
  166.     // Check the correct brush style button
  167.      CheckRadioButton(hdlg,
  168.                      IDD_BRUSHFIRST,
  169.                      IDD_BRUSHLAST,
  170.                      IDD_BRUSHSTYLE + lpLB->lbStyle);
  171.  
  172.     // Fill up the hatch style combobox.  The item data for each item is
  173.     // set to the hatch style value defined by Windows (e.g. HS_DIAGCROSS).
  174.  
  175.     hctlHatch = GetDlgItem(hdlg, IDD_HATCHSTYLE);
  176.     nSel = 0;
  177.  
  178.     for (i = IDD_HATCHFIRST; i <= IDD_HATCHLAST; i++)
  179.      {
  180.         LoadString(hInst, i, szTmp, sizeof(szTmp));
  181.         nIndex = SendMessage(hctlHatch, CB_ADDSTRING, 0, (LPARAM)(LPSTR)szTmp);
  182.         SendMessage(hctlHatch, CB_SETITEMDATA, nIndex, i - IDD_HATCHSTYLE);
  183.  
  184.         // If this item is the current style, remember it
  185.         if (i == IDD_HATCHSTYLE + (int)lpLB->lbHatch)
  186.             nSel = nIndex;
  187.     }
  188.  
  189.     // Set the initial hatch selection
  190.     SendMessage(hctlHatch, CB_SETCURSEL, nSel, 0L);
  191.  
  192.     // Center the dialog over the application window
  193.     CenterWindow(hdlg, GetWindow(hdlg, GW_OWNER));
  194.  
  195.     // Get coordinates of the example window in the dialog
  196.     GetWindowRect(GetDlgItem(hdlg, IDD_BRUSHEXAMPLE), &rcExample);
  197.     ScreenToClient(hdlg, (LPPOINT)&rcExample);
  198.     ScreenToClient(hdlg, ((LPPOINT)&rcExample) + 1);
  199.  
  200.     // Reduce rect slightly so we don't paint over its frame
  201.     InflateRect(&rcExample, -1, -1);
  202.  
  203.      return 1;
  204. }
  205.  
  206.  
  207. //
  208. //  FUNCTION: MsgBrushPaint(HWND, UINT, WPARAM, LPARAM)
  209. //
  210. //  PURPOSE: Paint the example window with the current brush style
  211. //
  212. //  PARAMETERS:
  213. //    hwnd - The window handling the message.
  214. //    uMessage - The message number. (unused).
  215. //    wparam - Message specific data (unused).
  216. //    lparam - Message specific data (unused).
  217. //
  218. //  RETURN VALUE:
  219. //    Always returns TRUE
  220. //
  221. //  COMMENTS:
  222. //
  223.  
  224. #pragma argsused
  225. LRESULT MsgBrushPaint(HWND hdlg, UINT uMessage, WPARAM wparam, LPARAM lparam)
  226. {
  227.      PAINTSTRUCT ps;
  228.      LPLOGBRUSH lpLB;
  229.      HBRUSH hbr;
  230.  
  231.     BeginPaint(hdlg, &ps);
  232.  
  233.     // Select our logical palette for palette-relative colors to work
  234.     if (hPalette)
  235.         SelectPalette(ps.hdc, hPalette, TRUE);
  236.  
  237.     // Get pointer to LOGBRUSH from window bytes
  238.     lpLB = (LPLOGBRUSH)GetWindowLong(hdlg, DWL_USER);
  239.  
  240.     // Create brush from current LOGBRUSH
  241.      hbr = CreateBrushIndirect(lpLB);
  242.  
  243.     // Paint the example window with the brush.
  244.     FillRect(ps.hdc, &rcExample, hbr);
  245.  
  246.     // Don't need the brush any more
  247.     DeleteObject(hbr);
  248.  
  249.     // De-select our logical palette from the DC
  250.     if (hPalette)
  251.         SelectPalette(ps.hdc, GetStockObject(DEFAULT_PALETTE), TRUE);
  252.  
  253.      EndPaint(hdlg, &ps);
  254.     return 0;
  255. }
  256.  
  257.  
  258. //
  259. //  FUNCTION: CmdBrushStyle(HWND, WORD, WORD, HWND)
  260. //
  261. //  PURPOSE: Keeps track of which style button is selected.
  262. //
  263. //  PARAMETERS:
  264. //    hwnd      - The window handling the command.
  265. //    wCommand  - Child control ID.
  266. //    wNotify   - Child notification code (unused).
  267. //    hwndCtrl  - NULL (unused).
  268. //
  269. //  RETURN VALUE:
  270. //    Always returns TRUE.
  271. //
  272. //  COMMENTS:
  273. //
  274.  
  275. #pragma argsused
  276. LRESULT CmdBrushStyle(HWND hdlg, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  277. {
  278.     // Get pointer to LOGBRUSH from window bytes
  279.     LPLOGBRUSH lpLB = (LPLOGBRUSH)GetWindowLong(hdlg, DWL_USER);
  280.  
  281.     // Save the style of the button that was just clicked
  282.     lpLB->lbStyle = wCommand - IDD_BRUSHSTYLE;
  283.  
  284.     // Repaint the example window
  285.      InvalidateRect(hdlg, &rcExample, TRUE);
  286.  
  287.     return TRUE;
  288. }
  289.  
  290.  
  291. //
  292. //  FUNCTION: CmdBrushHatch(HWND, WORD, WORD, HWND)
  293. //
  294. //  PURPOSE: Keeps track of which hatch style is selected.
  295. //
  296. //  PARAMETERS:
  297. //    hwnd      - The window handling the command.
  298. //    wCommand  - Child control ID (unused).
  299. //    wNotify   - Child notification code.
  300. //    hwndCtrl  - Handle to the Hatch Style combobox.
  301. //
  302. //  RETURN VALUE:
  303. //    Always returns TRUE.
  304. //
  305. //  COMMENTS:
  306. //
  307.  
  308. #pragma argsused
  309. LRESULT CmdBrushHatch(HWND hdlg, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  310. {
  311.      LPLOGBRUSH lpLB;
  312.      int nSel;
  313.  
  314.     // Update the hatch style selection if necessary.
  315.  
  316.     if (CBN_SELCHANGE == wNotify)
  317.     {
  318.         // Get pointer to LOGBRUSH from window bytes
  319.         lpLB = (LPLOGBRUSH)GetWindowLong(hdlg, DWL_USER);
  320.  
  321.         nSel = SendMessage(hwndCtrl, CB_GETCURSEL, 0, 0L);
  322.         if (CB_ERR != nSel)
  323.         {
  324.                 // Set brush style to hatched
  325.             lpLB->lbStyle = BS_HATCHED;
  326.             CheckRadioButton(hdlg,
  327.                              IDD_BRUSHFIRST,
  328.                              IDD_BRUSHLAST,
  329.                              IDD_HATCHBRUSH);
  330.  
  331.             // Save new hatch style
  332.             lpLB->lbHatch = SendMessage(hwndCtrl, CB_GETITEMDATA, nSel, 0L);
  333.  
  334.             // Repaint the example window
  335.             InvalidateRect(hdlg, &rcExample, TRUE);
  336.           }
  337.     }
  338.  
  339.     return TRUE;
  340. }
  341.  
  342.  
  343. //
  344. //  FUNCTION: CmdBrushColor(HWND, WORD, WORD, HWND)
  345. //
  346. //  PURPOSE: Puts up ChooseColor dialog to choose brush color.
  347. //
  348. //  PARAMETERS:
  349. //    hwnd      - The window handling the command.
  350. //    wCommand  - IDD_BRUSHCOLOR (unused).
  351. //    wNotify   - Child notification code (unused).
  352. //    hwndCtrl  - NULL (unused).
  353. //
  354. //  RETURN VALUE:
  355. //    Always returns TRUE.
  356. //
  357. //  COMMENTS:
  358. //
  359.  
  360. #pragma argsused
  361. LRESULT CmdBrushColor(HWND hdlg, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  362. {
  363.     LPLOGBRUSH lpLB;
  364.     static int nPalIndex=0; // stores system palette index for init'ing
  365.                             // the palette color selection dialog
  366.  
  367.     // Get pointer to LOGBRUSH from window bytes
  368.     lpLB = (LPLOGBRUSH)GetWindowLong(hdlg, DWL_USER);
  369.  
  370.     if (bPalDevice)
  371.     {
  372.         // call palette dialog, passing nPalIndex as LPARAM to initialize
  373.           // the correct selection in the dialog
  374.         DialogBoxParam(hInst, "ColorDlg", hdlg, (DLGPROC)Color, (LPARAM)nPalIndex);
  375.  
  376.         if (palinfo.index != -1)
  377.         {
  378.             // save index of color selection
  379.             nPalIndex = palinfo.index;
  380.  
  381.             if (palinfo.index >= 10 && palinfo.index <= 245)
  382.             {
  383.                 // Non-static color was chosen, so use PALETTERGB macro
  384.                 // to save new color
  385.                      lpLB->lbColor = PALETTERGB(palinfo.red, palinfo.green, palinfo.blue);
  386.             }
  387.             else
  388.             {
  389.                 // Static color was chosen, so just use RGB macro
  390.                 // to save new color
  391.                 lpLB->lbColor = RGB(palinfo.red, palinfo.green, palinfo.blue);
  392.             }
  393.         
  394.             // Repaint the example window
  395.             InvalidateRect(hdlg, &rcExample, TRUE);        
  396.         }
  397.  
  398.     }
  399.     else
  400.     {
  401.         CHOOSECOLOR  cc;
  402.         static DWORD dwCustColors[16];
  403.  
  404.         // Initialize CHOOSECOLOR struct
  405.         cc.lStructSize      = sizeof(cc);
  406.         cc.hwndOwner        = hdlg;
  407.         cc.hInstance        = NULL;
  408.         cc.rgbResult        = lpLB->lbColor;
  409.           cc.lpCustColors     = dwCustColors;
  410.         cc.Flags            = CC_RGBINIT;
  411.         cc.lCustData        = 0;
  412.         cc.lpfnHook         = NULL;
  413.         cc.lpTemplateName   = NULL;
  414.  
  415.         if (ChooseColor(&cc))
  416.         {
  417.             // Save new color
  418.             lpLB->lbColor = cc.rgbResult;
  419.  
  420.             // Repaint the example window
  421.                 InvalidateRect(hdlg, &rcExample, TRUE);
  422.         }
  423.     }
  424.  
  425.     return TRUE;
  426. }
  427.  
  428.  
  429. //
  430. //  FUNCTION: CmdBrushDone(HWND, WORD, HWND)
  431. //
  432. //  PURPOSE: Free the Brush dialog and related data.
  433. //
  434. //  PARAMETERS:
  435. //    hwnd      - The window handling the command.
  436. //    wCommand  - The command to be handled.
  437. //    hwndCtrl  - NULL (unused).
  438. //
  439. //  RETURN VALUE:
  440. //    Always returns TRUE.
  441. //
  442. //  COMMENTS:
  443. //    Calls EndDialog to finish the dialog session.
  444. //
  445.  
  446. #pragma argsused
  447. LRESULT CmdBrushDone(HWND hdlg, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  448. {
  449.     // Exit the dialog
  450.     EndDialog(hdlg, (IDOK == wCommand));
  451.  
  452.     return TRUE;
  453. }
  454.